package genericTest;

import org.junit.Test;

import java.util.*;

/**
 * @author 李泽伟 泛型的使用
 */
public class GenericTest {
    public static void main(String[] args) {
        //泛型不能是基本数据类型 int(x)，声明数据类型
        ArrayList<Integer> ints = new ArrayList<Integer>();
        //1.编译时就会进行类型检查，保证数据的安全
        ints.add(123);
        ints.add(22);
        //遍历1
        for(Integer obj:ints){
            //2.避免了强转操作
            System.out.println(obj);
        }
        //遍历2
        Iterator<Integer> iterator = ints.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    @Test
    public void test(){
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "lzj");
        map.put(2, "lzj");
        map.put(3, "1");
        map.put(4, "lzj");
        //泛型的嵌套 Map.Entry<Integer, String> Entry是内部类
        Set<Map.Entry<Integer, String>> set = map.entrySet();

        Iterator<Map.Entry<Integer, String>> iterator = set.iterator();
        while (iterator.hasNext()){
            Map.Entry<Integer, String> next = iterator.next();
            System.out.println(next.getKey() + ":" + next.getValue());
        }
        for (Map.Entry<Integer, String> next : set) {
            System.out.println(next.getKey() + ":" + next.getValue());
        }
    }
    @Test
    public void test1(){
        ArrayList<Integer> list = new ArrayList<Integer>();
        ArrayList<String> list1 = new ArrayList<>();

    }
    @Test
    public void test2(){
        Integer[] integers = new Integer[]{1, 2, 3, 4};
        //        List<Integer> list = methodWithList(integers);
        List<Integer> list = methodWithList(integers);
        System.out.println(list);
    }
    //泛型方法
    public <E> List<E> methodWithList(E[] arr){
        ArrayList<E> es = new ArrayList<>();
        for (E obj:arr) {
            es.add(obj);
        }
        return es;
    }
    @Test
    public void test3() {
        List<Object> list1 = null;
        List<String> list2 = null;
        // 编译不通过，不具备子父类关系，是完全并列的关系
        // 类A是类B的父类，但G<A>和G<B>不具备子父类关系，
//        list1 = list2;
        ArrayList<String> list3 = null;
        // 可以通过
        list2 = list3;
    }
    @Test
    public void test4() {
        List<String> list1 = new ArrayList<>();
        list1.add("aa");
        List<?> list = null;
        list = list1;
        // 编译不通过，无法写入
        //list.add();
        //允许读取
        Object o = list.get(0);
        System.out.println(o);
    }
    @Test
    public void test5() {
        // G<? extends A>可以作为G<A>和G<B>的父类，其中B是A的子类
        List<? extends Person> list = null;
        // G<? super A>可以作为G<A>和G<B>的父类，其中B是A的父类
        List<? super Person> list1 = null;
    }
}



